{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding REINFORCE (Monte Carlo Policy Gradient): A Complete Guide\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction](#introduction)\n",
    "- [What is REINFORCE?](#what-is-reinforce)\n",
    "  - [Why Policy Gradients?](#why-policy-gradients)\n",
    "- [Where and How REINFORCE is Used](#where-and-how-reinforce-is-used)\n",
    "- [Mathematical Foundation of REINFORCE](#mathematical-foundation-of-reinforce)\n",
    "  - [Policy Gradient Theorem Recap (Intuition)](#policy-gradient-theorem-recap)\n",
    "  - [The REINFORCE Objective Function](#the-reinforce-objective-function)\n",
    "  - [The REINFORCE Gradient Estimator](#the-reinforce-gradient-estimator)\n",
    "  - [Calculating Discounted Returns (Monte Carlo)](#calculating-discounted-returns)\n",
    "- [Step-by-Step Explanation of REINFORCE](#step-by-step-explanation-of-reinforce)\n",
    "- [Key Components of REINFORCE](#key-components-of-reinforce)\n",
    "  - [Policy Network](#policy-network)\n",
    "  - [Action Selection (Sampling)](#action-selection-sampling)\n",
    "  - [Trajectory Collection](#trajectory-collection)\n",
    "  - [Discounted Returns Calculation](#discounted-returns-calculation)\n",
    "  - [Loss Function (Policy Gradient Objective)](#loss-function-policy-gradient-objective)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Custom Grid World](#practical-example-custom-grid-world)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Custom Environment](#creating-the-custom-environment)\n",
    "- [Implementing the REINFORCE Algorithm](#implementing-the-reinforce-algorithm)\n",
    "  - [Defining the Policy Network](#defining-the-policy-network)\n",
    "  - [Action Selection (Sampling from Policy)](#action-selection-sampling-from-policy)\n",
    "  - [Calculating Returns](#calculating-returns)\n",
    "  - [Optimization Step (Policy Update)](#optimization-step-policy-update)\n",
    "- [Running the REINFORCE Algorithm](#running-the-reinforce-algorithm)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Initialization](#initialization)\n",
    "  - [Training Loop](#training-loop)\n",
    "- [Visualizing the Learning Process](#visualizing-the-learning-process)\n",
    "- [Analyzing the Learned Policy (Optional Visualization)](#analyzing-the-learned-policy-optional-visualization)\n",
    "- [Common Challenges and Solutions in REINFORCE](#common-challenges-and-solutions-in-reinforce)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Reinforcement Learning (RL) aims to train agents to make sequences of decisions in an environment to maximize a cumulative reward. While value-based methods like Q-learning (and DQN) learn the value of state-action pairs, policy-based methods directly learn a policy, which is a mapping from states to actions (or action probabilities). REINFORCE, also known as Monte Carlo Policy Gradient, is a foundational policy gradient algorithm.\n",
    "\n",
    "## What is REINFORCE?\n",
    "\n",
    "REINFORCE is an algorithm that learns a parameterized policy $\\pi(a|s; \\theta)$ directly, without explicitly learning a value function first. It works by:\n",
    "\n",
    "1.  Executing the current policy $\\pi(a|s; \\theta)$ to generate full episodes (trajectories) of experience: $(s_0, a_0, r_1, s_1, a_1, r_2, ..., s_T)$.\n",
    "2.  For each step $t$ in the episode, calculating the total discounted return $G_t = \\sum_{k=t}^T \\gamma^{k-t} r_{k+1}$ obtained from that step onwards.\n",
    "3.  Updating the policy parameters $\\theta$ using gradient ascent to increase the probability of actions $a_t$ that led to high returns $G_t$ and decrease the probability of actions that led to low returns.\n",
    "\n",
    "It's considered a **Monte Carlo** method because it uses the complete return $G_t$ from entire episodes to update the policy, rather than bootstrapping from estimated values like Q-learning or Actor-Critic methods.\n",
    "\n",
    "### Why Policy Gradients?\n",
    "\n",
    "Policy gradient methods offer several advantages over purely value-based methods like DQN:\n",
    "\n",
    "1.  **Continuous Action Spaces:** They can naturally handle continuous action spaces, whereas DQN is primarily designed for discrete actions.\n",
    "2.  **Stochastic Policies:** They can learn stochastic policies ($pi(a|s)$ gives probabilities), which can be beneficial in partially observable environments or when seeking robustness.\n",
    "3.  **Simpler Conceptually (in some ways):** Directly optimizing the policy can sometimes be more straightforward than estimating values, especially when the value function is complex.\n",
    "\n",
    "However, basic policy gradient methods like REINFORCE often suffer from high variance in their gradient estimates due to the Monte Carlo sampling, which can lead to slower or less stable convergence compared to methods like DQN or Actor-Critic.\n",
    "\n",
    "## Where and How REINFORCE is Used\n",
    "\n",
    "REINFORCE serves as a fundamental building block for understanding more advanced policy gradient and actor-critic methods. While its high variance limits its direct application in complex, large-scale problems compared to state-of-the-art algorithms, it's effective for:\n",
    "\n",
    "1.  **Simpler RL Benchmarks:** Problems like CartPole, Acrobot, or custom grid worlds where trajectories are relatively short and variance is manageable.\n",
    "2.  **Learning Stochastic Policies:** Situations where a probabilistic action selection is desirable.\n",
    "3.  **Educational Purposes:** Provides a clear introduction to the core concepts of policy gradient learning.\n",
    "\n",
    "REINFORCE is suitable when:\n",
    "- The goal is to directly learn a policy.\n",
    "- The environment allows for generating full episodes before updating.\n",
    "- The action space can be discrete or continuous (though our example uses discrete).\n",
    "- High variance in updates is acceptable or can be managed (e.g., through baselines, though not implemented here).\n",
    "- It operates **on-policy**, meaning the policy used to generate data is the same one being improved. Data from old policies cannot be easily reused (unlike DQN's off-policy nature with replay buffers).\n",
    "\n",
    "## Mathematical Foundation of REINFORCE\n",
    "\n",
    "### Policy Gradient Theorem Recap (Intuition)\n",
    "\n",
    "The goal is to find policy parameters $\\theta$ that maximize the expected total discounted return, often denoted as $J(\\theta)$. The Policy Gradient Theorem provides a way to compute the gradient of this objective with respect to the policy parameters:\n",
    "$$ \\nabla_\\theta J(\\theta) = \\mathbb{E}_{\\tau \\sim \\pi_\\theta} \\left[ \\sum_{t=0}^T \\nabla_\\theta \\log \\pi_\\theta(a_t | s_t) Q^{\\pi_\\theta}(s_t, a_t) \\right] $$\n",
    "where $\\tau$ is a trajectory sampled using policy $\\pi_\\theta$, and $Q^{\\pi_\\theta}(s_t, a_t)$ is the action-value function under policy $\\pi_\\theta$.\n",
    "\n",
    "### The REINFORCE Objective Function\n",
    "\n",
    "REINFORCE uses the Monte Carlo return $G_t = \\sum_{k=t}^T \\gamma^{k-t} r_{k+1}$ as an unbiased estimate of $Q^{\\pi_\\theta}(s_t, a_t)$. The gradient then becomes:\n",
    "$$ \\nabla_\\theta J(\\theta) = \\mathbb{E}_{\\tau \\sim \\pi_\\theta} \\left[ \\sum_{t=0}^T G_t \\nabla_\\theta \\log \\pi_\\theta(a_t | s_t) \\right] $$\n",
    "\n",
    "We want to perform gradient *ascent* on $J(\\theta)$. This is equivalent to performing gradient *descent* on the negative objective, which gives us the typical loss function used in implementations:\n",
    "$$ L(\\theta) = - \\mathbb{E}_{\\tau \\sim \\pi_\\theta} \\left[ \\sum_{t=0}^T G_t \\log \\pi_\\theta(a_t | s_t) \\right] $$\n",
    "\n",
    "In practice, we approximate the expectation using samples (episodes) generated by the current policy.\n",
    "\n",
    "### The REINFORCE Gradient Estimator\n",
    "\n",
    "For a single trajectory $\\tau$, the gradient estimate is $\\sum_{t=0}^T G_t \\nabla_\\theta \\log \\pi_\\theta(a_t | s_t)$.\n",
    "The term $\\nabla_\\theta \\log \\pi_\\theta(a_t | s_t)$ is often called the \"eligibility vector\". It indicates the direction in parameter space that increases the log-probability of taking action $a_t$ in state $s_t$. This direction is then scaled by the return $G_t$. If $G_t$ is high, we move significantly in that direction; if $G_t$ is low (or negative), we move away from that direction.\n",
    "\n",
    "### Calculating Discounted Returns (Monte Carlo)\n",
    "\n",
    "After an episode finishes and we have the sequence of rewards $r_1, r_2, ..., r_T$, we calculate the discounted return for each time step $t$:\n",
    "$$ G_t = r_{t+1} + \\gamma r_{t+2} + \\gamma^2 r_{t+3} + ... + \\gamma^{T-t} r_T $$\n",
    "This calculation is typically done efficiently by iterating backward from the end of the episode:\n",
    "$G_T = 0$ (assuming $r_{T+1}=0$ or depends on problem setup)\n",
    "$G_{T-1} = r_T + \\gamma G_T$\n",
    "$G_{T-2} = r_{T-1} + \\gamma G_{T-1}$\n",
    "... and so on until $G_0$.\n",
    "\n",
    "**Variance Reduction (Baselines):** A common technique (though not implemented in this basic example) is to subtract a state-dependent baseline $b(s_t)$ (often the state-value function $V(s_t)$) from the return: $\n",
    "abla_\theta J(\\theta) \\approx \\sum_t (G_t - b(s_t)) \\nabla_\\theta \\log \\pi_\\theta(a_t|s_t)$. This doesn't change the expected gradient but significantly reduces its variance.\n",
    "\n",
    "## Step-by-Step Explanation of REINFORCE\n",
    "\n",
    "1.  **Initialize**: Policy network $\\pi(a|s; \\theta)$ with random weights $\\theta$, discount factor $\\gamma$, learning rate $\\alpha$.\n",
    "2.  **For each episode**:\n",
    "    a.  Generate a full trajectory $\\tau = (s_0, a_0, r_1, s_1, a_1, ..., s_{T-1}, a_{T-1}, r_T, s_T)$ by following policy $\\pi(a|s; \\theta)$:\n",
    "        i.  For $t=0, 1, ..., T-1$:\n",
    "            - Observe state $s_t$.\n",
    "            - Sample action $a_t \\sim \\pi(\\cdot | s_t; \\theta)$.\n",
    "            - Execute $a_t$, observe reward $r_{t+1}$ and next state $s_{t+1}$.\n",
    "            - Store $s_t, a_t, r_{t+1}$, and $\\log \\pi_\\theta(a_t | s_t)$.\n",
    "    b.  **Calculate Returns**: For $t=0, 1, ..., T-1$:\n",
    "        - Compute the discounted return $G_t = \\sum_{k=t}^{T-1} \\gamma^{k-t} r_{k+1}$.\n",
    "    c.  **Update Policy**: Perform gradient ascent (or descent on the negative objective):\n",
    "        - Compute the loss $L = -\\sum_{t=0}^{T-1} G_t \\log \\pi_\\theta(a_t | s_t)$.\n",
    "        - Update weights: $\\theta \\leftarrow \\theta + \\alpha \\nabla_\\theta J(\\theta)$ (or using an optimizer on $L$).\n",
    "3.  **Repeat**: Until convergence or max episodes.\n",
    "\n",
    "## Key Components of REINFORCE\n",
    "\n",
    "### Policy Network\n",
    "- The core function approximator. Learns to map states to action probabilities.\n",
    "- Architecture depends on the state representation (MLP for vectors, CNN for images).\n",
    "- Uses non-linear activation functions (like ReLU) in hidden layers.\n",
    "- Output layer typically uses a **Softmax** activation for discrete action spaces to produce a probability distribution over actions.\n",
    "\n",
    "### Action Selection (Sampling)\n",
    "- Actions are **sampled** from the probability distribution output by the policy network $\\pi(a|s; \\theta)$.\n",
    "- This inherently provides exploration. As learning progresses, probabilities for better actions increase, leading to more exploitation.\n",
    "- Requires storing the **log probability** of the chosen action ($log \\pi(a_t|s_t; \\theta)$) for the gradient calculation.\n",
    "\n",
    "### Trajectory Collection\n",
    "- REINFORCE is **on-policy** and **episodic**.\n",
    "- It requires collecting full episodes (state, action, reward sequences) using the current policy before an update can be made.\n",
    "- Stores rewards, states, actions, and log probabilities for each step.\n",
    "\n",
    "### Discounted Returns Calculation\n",
    "- After an episode, calculate $G_t$ for every step $t$.\n",
    "- This value represents the actual cumulative reward received from that point onwards in that specific episode.\n",
    "\n",
    "### Loss Function (Policy Gradient Objective)\n",
    "- Typically $-\\sum_t G_t \\log \\pi(a_t|s_t; \\theta)$.\n",
    "- Maximizing the probability of actions that led to high returns.\n",
    "- Often, returns $G_t$ are **standardized** (subtract mean, divide by std dev) across the episode's batch of returns to stabilize learning.\n",
    "\n",
    "### Hyperparameters\n",
    "- Key hyperparameters include learning rate, discount factor $\\gamma$, and network architecture.\n",
    "- Performance can be sensitive to these, especially the learning rate, due to the variance of the gradient estimate.\n",
    "\n",
    "## Practical Example: Custom Grid World\n",
    "\n",
    "We'll use the same simple, custom Grid World environment as in the DQN example for comparison and to adhere to the style.\n",
    "\n",
    "**Environment Description:**\n",
    "- **Grid Size:** 10x10.\n",
    "- **State:** Agent's `(row, col)` position. Represented as a normalized vector `[row/10, col/10]` for the network input.\n",
    "- **Actions:** 4 discrete actions: 0 (up), 1 (down), 2 (left), 3 (right).\n",
    "- **Start State:** (0, 0).\n",
    "- **Goal State:** (9, 9).\n",
    "- **Rewards:**\n",
    "    - +10 for reaching the goal state (9, 9).\n",
    "    - -1 for hitting a wall (attempting to move off-grid).\n",
    "    - -0.1 for any other step (small cost to encourage efficiency).\n",
    "- **Termination:** Episode ends when the agent reaches the goal or after a maximum number of steps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "Import required libraries and set up the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries for numerical computations, plotting, and utility functions\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import math\n",
    "from collections import namedtuple, deque # Deque might not be needed for REINFORCE\n",
    "from itertools import count\n",
    "from typing import List, Tuple, Dict, Optional\n",
    "\n",
    "# Import PyTorch for building and training neural networks\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Categorical # Needed for sampling actions\n",
    "\n",
    "# Set up the device to use GPU if available, otherwise fallback to CPU\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Set a random seed for reproducibility across runs\n",
    "seed = 42\n",
    "random.seed(seed)  # Seed for Python's random module\n",
    "np.random.seed(seed)  # Seed for NumPy\n",
    "torch.manual_seed(seed)  # Seed for PyTorch (CPU)\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.manual_seed_all(seed)  # Seed for PyTorch (GPU)\n",
    "\n",
    "# Enable inline plotting for Jupyter Notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Custom Environment\n",
    "\n",
    "We reuse the exact same `GridEnvironment` class from the DQN notebook. This ensures comparability and adheres to the reference style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Custom Grid World Environment (Identical to the one in DQN notebook)\n",
    "class GridEnvironment:\n",
    "    \"\"\"\n",
    "    A simple 10x10 Grid World environment.\n",
    "    State: (row, col) represented as normalized vector [row/10, col/10].\n",
    "    Actions: 0 (up), 1 (down), 2 (left), 3 (right).\n",
    "    Rewards: +10 for reaching the goal, -1 for hitting a wall, -0.1 for each step.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, rows: int = 10, cols: int = 10) -> None:\n",
    "        \"\"\"\n",
    "        Initializes the Grid World environment.\n",
    "\n",
    "        Parameters:\n",
    "        - rows (int): Number of rows in the grid.\n",
    "        - cols (int): Number of columns in the grid.\n",
    "        \"\"\"\n",
    "        self.rows: int = rows\n",
    "        self.cols: int = cols\n",
    "        self.start_state: Tuple[int, int] = (0, 0)  # Starting position\n",
    "        self.goal_state: Tuple[int, int] = (rows - 1, cols - 1)  # Goal position\n",
    "        self.state: Tuple[int, int] = self.start_state  # Current state\n",
    "        self.state_dim: int = 2  # State represented by 2 coordinates (row, col)\n",
    "        self.action_dim: int = 4  # 4 discrete actions: up, down, left, right\n",
    "\n",
    "        # Action mapping: maps action index to (row_delta, col_delta)\n",
    "        self.action_map: Dict[int, Tuple[int, int]] = {\n",
    "            0: (-1, 0),  # Up\n",
    "            1: (1, 0),   # Down\n",
    "            2: (0, -1),  # Left\n",
    "            3: (0, 1)    # Right\n",
    "        }\n",
    "\n",
    "    def reset(self) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Resets the environment to the start state.\n",
    "\n",
    "        Returns:\n",
    "            torch.Tensor: The initial state as a normalized tensor.\n",
    "        \"\"\"\n",
    "        self.state = self.start_state\n",
    "        return self._get_state_tensor(self.state)\n",
    "\n",
    "    def _get_state_tensor(self, state_tuple: Tuple[int, int]) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Converts a (row, col) tuple to a normalized tensor for the network.\n",
    "\n",
    "        Parameters:\n",
    "        - state_tuple (Tuple[int, int]): The state represented as a tuple (row, col).\n",
    "\n",
    "        Returns:\n",
    "            torch.Tensor: The normalized state as a tensor.\n",
    "        \"\"\"\n",
    "        # Normalize coordinates to be between 0 and 1 (adjust normalization slightly for 0-based indexing)\n",
    "        normalized_state: List[float] = [\n",
    "            state_tuple[0] / (self.rows - 1) if self.rows > 1 else 0.0,\n",
    "            state_tuple[1] / (self.cols - 1) if self.cols > 1 else 0.0\n",
    "        ]\n",
    "        return torch.tensor(normalized_state, dtype=torch.float32, device=device)\n",
    "\n",
    "    def step(self, action: int) -> Tuple[torch.Tensor, float, bool]:\n",
    "        \"\"\"\n",
    "        Performs one step in the environment based on the given action.\n",
    "\n",
    "        Args:\n",
    "            action (int): The action to take (0: up, 1: down, 2: left, 3: right).\n",
    "\n",
    "        Returns:\n",
    "            Tuple[torch.Tensor, float, bool]: \n",
    "                - next_state_tensor (torch.Tensor): The next state as a normalized tensor.\n",
    "                - reward (float): The reward for the action.\n",
    "                - done (bool): Whether the episode has ended.\n",
    "        \"\"\"\n",
    "        # If the goal state is already reached, return the current state with 0 reward and done=True\n",
    "        if self.state == self.goal_state:\n",
    "            return self._get_state_tensor(self.state), 0.0, True\n",
    "\n",
    "        # Get the row and column deltas for the action\n",
    "        dr, dc = self.action_map[action]\n",
    "        current_row, current_col = self.state\n",
    "        next_row, next_col = current_row + dr, current_col + dc\n",
    "\n",
    "        # Default step cost\n",
    "        reward: float = -0.1\n",
    "        hit_wall: bool = False\n",
    "\n",
    "        # Check if the action leads to hitting a wall (out of bounds)\n",
    "        if not (0 <= next_row < self.rows and 0 <= next_col < self.cols):\n",
    "            # Stay in the same state and incur a penalty\n",
    "            next_row, next_col = current_row, current_col\n",
    "            reward = -1.0\n",
    "            hit_wall = True\n",
    "\n",
    "        # Update the state\n",
    "        self.state = (next_row, next_col)\n",
    "        next_state_tensor: torch.Tensor = self._get_state_tensor(self.state)\n",
    "\n",
    "        # Check if the goal state is reached\n",
    "        done: bool = (self.state == self.goal_state)\n",
    "        if done:\n",
    "            reward = 10.0  # Reward for reaching the goal\n",
    "\n",
    "        return next_state_tensor, reward, done\n",
    "\n",
    "    def get_action_space_size(self) -> int:\n",
    "        \"\"\"\n",
    "        Returns the size of the action space.\n",
    "\n",
    "        Returns:\n",
    "            int: The number of possible actions (4).\n",
    "        \"\"\"\n",
    "        return self.action_dim\n",
    "\n",
    "    def get_state_dimension(self) -> int:\n",
    "        \"\"\"\n",
    "        Returns the dimension of the state representation.\n",
    "\n",
    "        Returns:\n",
    "            int: The number of dimensions in the state (2).\n",
    "        \"\"\"\n",
    "        return self.state_dim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instantiate the custom environment and verify its properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Custom Grid Environment:\n",
      "Size: 10x10\n",
      "State Dim: 2\n",
      "Action Dim: 4\n",
      "Start State: (0, 0)\n",
      "Goal State: (9, 9)\n",
      "Example state tensor for (0,0): tensor([0., 0.])\n",
      "Step result (action=right): next_state=[0.         0.11111111], reward=-0.1, done=False\n",
      "Step result (action=up): next_state=[0.         0.11111111], reward=-1.0, done=False\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the custom grid environment with a 10x10 grid\n",
    "custom_env = GridEnvironment(rows=10, cols=10)\n",
    "\n",
    "# Get the size of the action space and state dimension\n",
    "n_actions_custom = custom_env.get_action_space_size()\n",
    "n_observations_custom = custom_env.get_state_dimension()\n",
    "\n",
    "# Print basic information about the environment\n",
    "print(f\"Custom Grid Environment:\")\n",
    "print(f\"Size: {custom_env.rows}x{custom_env.cols}\")\n",
    "print(f\"State Dim: {n_observations_custom}\")\n",
    "print(f\"Action Dim: {n_actions_custom}\")\n",
    "print(f\"Start State: {custom_env.start_state}\")\n",
    "print(f\"Goal State: {custom_env.goal_state}\")\n",
    "\n",
    "# Reset the environment and print the normalized state tensor for the start state\n",
    "print(f\"Example state tensor for (0,0): {custom_env.reset()}\")\n",
    "\n",
    "# Take an example step: move 'right' (action=3) and print the result\n",
    "next_s, r, d = custom_env.step(3) # Action 3 corresponds to moving right\n",
    "print(f\"Step result (action=right): next_state={next_s.cpu().numpy()}, reward={r}, done={d}\")\n",
    "\n",
    "# Take another example step: move 'up' (action=0) and print the result\n",
    "# This should hit a wall since the agent is at the top row\n",
    "next_s, r, d = custom_env.step(0) # Action 0 corresponds to moving up\n",
    "print(f\"Step result (action=up): next_state={next_s.cpu().numpy()}, reward={r}, done={d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the REINFORCE Algorithm\n",
    "\n",
    "Now, let's implement the core components: the Policy Network, the action selection mechanism (sampling), the return calculation, and the policy update step.\n",
    "\n",
    "### Defining the Policy Network\n",
    "\n",
    "We define a simple Multi-Layer Perceptron (MLP) using PyTorch's `nn.Module`. The key difference from the DQN network is the output layer, which uses `nn.Softmax` to produce action probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the Policy Network architecture\n",
    "class PolicyNetwork(nn.Module):\n",
    "    \"\"\" Simple MLP Policy Network for REINFORCE \"\"\"\n",
    "    def __init__(self, n_observations: int, n_actions: int):\n",
    "        \"\"\"\n",
    "        Initialize the Policy Network.\n",
    "\n",
    "        Parameters:\n",
    "        - n_observations (int): Dimension of the state space.\n",
    "        - n_actions (int): Number of possible actions.\n",
    "        \"\"\"\n",
    "        super(PolicyNetwork, self).__init__()\n",
    "        # Define network layers (similar structure to DQN reference)\n",
    "        self.layer1 = nn.Linear(n_observations, 128) # Input layer\n",
    "        self.layer2 = nn.Linear(128, 128)           # Hidden layer\n",
    "        self.layer3 = nn.Linear(128, n_actions)      # Output layer (action logits)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Forward pass through the network to get action probabilities.\n",
    "\n",
    "        Parameters:\n",
    "        - x (torch.Tensor): Input tensor representing the state(s).\n",
    "\n",
    "        Returns:\n",
    "        - torch.Tensor: Output tensor representing action probabilities (after Softmax).\n",
    "        \"\"\"\n",
    "        # Ensure input is float tensor\n",
    "        if not isinstance(x, torch.Tensor):\n",
    "             x = torch.tensor(x, dtype=torch.float32, device=device)\n",
    "        elif x.dtype != torch.float32:\n",
    "             x = x.to(dtype=torch.float32)\n",
    "\n",
    "        # Apply layers with ReLU activation for hidden layers\n",
    "        x = F.relu(self.layer1(x))\n",
    "        x = F.relu(self.layer2(x))\n",
    "        # Get action logits from the output layer\n",
    "        action_logits = self.layer3(x)\n",
    "        # Apply Softmax to get action probabilities\n",
    "        action_probs = F.softmax(action_logits, dim=-1) # Use dim=-1 for generality (works for batches)\n",
    "        return action_probs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Action Selection (Sampling from Policy)\n",
    "\n",
    "This function selects an action by sampling from the probability distribution provided by the policy network. It also returns the log probability of the selected action, which is needed for the REINFORCE update."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Action Selection for REINFORCE\n",
    "def select_action_reinforce(state: torch.Tensor, policy_net: PolicyNetwork) -> Tuple[int, torch.Tensor]:\n",
    "    \"\"\"\n",
    "    Selects an action by sampling from the policy network's output distribution.\n",
    "\n",
    "    Parameters:\n",
    "    - state (torch.Tensor): The current state as a tensor of shape [state_dim].\n",
    "    - policy_net (PolicyNetwork): The policy network used to estimate action probabilities.\n",
    "\n",
    "    Returns:\n",
    "    - Tuple[int, torch.Tensor]:\n",
    "        - action (int): The selected action index.\n",
    "        - log_prob (torch.Tensor): The log probability of the selected action.\n",
    "    \"\"\"\n",
    "    # Ensure the network is in evaluation mode if it has dropout/batchnorm layers (optional here)\n",
    "    # policy_net.eval() \n",
    "\n",
    "    # Get action probabilities from the policy network\n",
    "    # Add batch dimension if state is single instance [state_dim] -> [1, state_dim]\n",
    "    if state.dim() == 1:\n",
    "        state = state.unsqueeze(0)\n",
    "    \n",
    "    action_probs = policy_net(state)\n",
    "\n",
    "    # Create a categorical distribution over the actions\n",
    "    # Squeeze(0) if we added a batch dimension earlier to get probs for the single state\n",
    "    m = Categorical(action_probs.squeeze(0)) \n",
    "    \n",
    "    # Sample an action from the distribution\n",
    "    action = m.sample()\n",
    "    \n",
    "    # Get the log probability of the sampled action (needed for gradient calculation)\n",
    "    log_prob = m.log_prob(action)\n",
    "\n",
    "    # Put network back to training mode if needed\n",
    "    # policy_net.train()\n",
    "\n",
    "    # Return the action index (as int) and its log probability (as tensor)\n",
    "    return action.item(), log_prob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating Returns\n",
    "\n",
    "This function calculates the discounted returns $G_t$ for each step in an episode, given the list of rewards. It optionally standardizes the returns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_discounted_returns(rewards: List[float], gamma: float, standardize: bool = True) -> torch.Tensor:\n",
    "    \"\"\"\n",
    "    Calculates the discounted returns G_t for each step t in an episode.\n",
    "\n",
    "    Parameters:\n",
    "    - rewards (List[float]): List of rewards received during the episode.\n",
    "    - gamma (float): The discount factor.\n",
    "    - standardize (bool): Whether to standardize (normalize) the returns (subtract mean, divide by std).\n",
    "\n",
    "    Returns:\n",
    "    - torch.Tensor: A tensor containing the discounted return for each step.\n",
    "    \"\"\"\n",
    "    n_steps = len(rewards)\n",
    "    returns = torch.zeros(n_steps, device=device, dtype=torch.float32)\n",
    "    discounted_return = 0.0\n",
    "\n",
    "    # Iterate backwards through the rewards to calculate discounted returns\n",
    "    for t in reversed(range(n_steps)):\n",
    "        discounted_return = rewards[t] + gamma * discounted_return\n",
    "        returns[t] = discounted_return\n",
    "\n",
    "    # Standardize returns (optional but often helpful)\n",
    "    if standardize:\n",
    "        mean_return = torch.mean(returns)\n",
    "        std_return = torch.std(returns) + 1e-8 # Add small epsilon to prevent division by zero\n",
    "        returns = (returns - mean_return) / std_return\n",
    "\n",
    "    return returns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization Step (Policy Update)\n",
    "\n",
    "This function performs the policy update after an episode is completed. It takes the collected log probabilities and calculated returns to compute the loss and perform backpropagation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_policy(\n",
    "    log_probs: List[torch.Tensor], \n",
    "    returns: torch.Tensor, \n",
    "    optimizer: optim.Optimizer\n",
    ") -> float:\n",
    "    \"\"\"\n",
    "    Performs one step of optimization on the policy network using REINFORCE update rule.\n",
    "\n",
    "    Parameters:\n",
    "    - log_probs (List[torch.Tensor]): List of log probabilities of actions taken in the episode.\n",
    "    - returns (torch.Tensor): Tensor of discounted returns for each step in the episode.\n",
    "    - optimizer (optim.Optimizer): The optimizer for updating the policy network.\n",
    "\n",
    "    Returns:\n",
    "    - float: The computed loss value for the episode.\n",
    "    \"\"\"\n",
    "    # Stack log probabilities into a single tensor\n",
    "    log_probs_tensor = torch.stack(log_probs)\n",
    "\n",
    "    # Calculate the REINFORCE loss: - (returns * log_probs)\n",
    "    # We want to maximize E[G_t * log(pi)], so we minimize -E[G_t * log(pi)]\n",
    "    # Sum over the episode steps\n",
    "    loss = -torch.sum(returns * log_probs_tensor)\n",
    "\n",
    "    # Perform backpropagation and optimization\n",
    "    optimizer.zero_grad()  # Clear previous gradients\n",
    "    loss.backward()       # Compute gradients\n",
    "    optimizer.step()      # Update the policy network parameters\n",
    "\n",
    "    return loss.item()    # Return the loss value for logging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the REINFORCE Algorithm\n",
    "\n",
    "Set up the hyperparameters, initialize the policy network and optimizer, then run the main training loop.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "Define hyperparameters for the REINFORCE algorithm applied to the custom grid world."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for REINFORCE on Custom Grid World\n",
    "GAMMA_REINFORCE = 0.99         # Discount factor\n",
    "LR_REINFORCE = 1e-3            # Learning rate (often lower than DQN, sensitive)\n",
    "NUM_EPISODES_REINFORCE = 1500  # REINFORCE often needs more episodes due to variance\n",
    "MAX_STEPS_PER_EPISODE_REINFORCE = 200 # Max steps per episode\n",
    "STANDARDIZE_RETURNS = True     # Whether to standardize returns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization\n",
    "\n",
    "Initialize the policy network and the optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Re-instantiate the custom GridEnvironment\n",
    "custom_env: GridEnvironment = GridEnvironment(rows=10, cols=10)\n",
    "\n",
    "# Get the size of the action space and state dimension\n",
    "n_actions_custom: int = custom_env.get_action_space_size()  # 4 actions\n",
    "n_observations_custom: int = custom_env.get_state_dimension()  # 2 state dimensions\n",
    "\n",
    "# Initialize the policy network\n",
    "policy_net_reinforce: PolicyNetwork = PolicyNetwork(n_observations_custom, n_actions_custom).to(device)\n",
    "\n",
    "# Initialize the optimizer for the policy network\n",
    "optimizer_reinforce: optim.Adam = optim.Adam(policy_net_reinforce.parameters(), lr=LR_REINFORCE)\n",
    "\n",
    "# Lists for storing episode statistics for plotting\n",
    "episode_rewards_reinforce = []\n",
    "episode_lengths_reinforce = []\n",
    "episode_losses_reinforce = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop\n",
    "\n",
    "Train the REINFORCE agent on the custom grid world environment. Note the difference in workflow compared to DQN: we collect a full episode first, then calculate returns and update the policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting REINFORCE Training on Custom Grid World...\n",
      "Episode 100/1500 | Avg Reward (last 100): 0.31 | Avg Length: 43.90 | Avg Loss: -2.5428\n",
      "Episode 200/1500 | Avg Reward (last 100): 5.83 | Avg Length: 21.42 | Avg Loss: -1.5049\n",
      "Episode 300/1500 | Avg Reward (last 100): 6.93 | Avg Length: 20.16 | Avg Loss: -1.6836\n",
      "Episode 400/1500 | Avg Reward (last 100): 7.20 | Avg Length: 19.39 | Avg Loss: -1.2332\n",
      "Episode 500/1500 | Avg Reward (last 100): 7.34 | Avg Length: 19.16 | Avg Loss: -1.0108\n",
      "Episode 600/1500 | Avg Reward (last 100): 7.43 | Avg Length: 19.23 | Avg Loss: -1.1386\n",
      "Episode 700/1500 | Avg Reward (last 100): 7.66 | Avg Length: 18.73 | Avg Loss: -0.2648\n",
      "Episode 800/1500 | Avg Reward (last 100): 7.96 | Avg Length: 18.52 | Avg Loss: -0.4335\n",
      "Episode 900/1500 | Avg Reward (last 100): 7.93 | Avg Length: 18.57 | Avg Loss: 0.6314\n",
      "Episode 1000/1500 | Avg Reward (last 100): 7.95 | Avg Length: 18.42 | Avg Loss: 1.5364\n",
      "Episode 1100/1500 | Avg Reward (last 100): 7.87 | Avg Length: 18.45 | Avg Loss: 2.0860\n",
      "Episode 1200/1500 | Avg Reward (last 100): 7.95 | Avg Length: 18.42 | Avg Loss: 1.9074\n",
      "Episode 1300/1500 | Avg Reward (last 100): 7.91 | Avg Length: 18.44 | Avg Loss: 1.6792\n",
      "Episode 1400/1500 | Avg Reward (last 100): 7.85 | Avg Length: 18.63 | Avg Loss: 1.1213\n",
      "Episode 1500/1500 | Avg Reward (last 100): 7.74 | Avg Length: 18.60 | Avg Loss: 1.5478\n",
      "Custom Grid World Training Finished (REINFORCE).\n"
     ]
    }
   ],
   "source": [
    "print(\"Starting REINFORCE Training on Custom Grid World...\")\n",
    "\n",
    "# Training Loop\n",
    "for i_episode in range(NUM_EPISODES_REINFORCE):\n",
    "    # Reset the environment and get the initial state tensor\n",
    "    state = custom_env.reset()\n",
    "    \n",
    "    # Lists to store data for the current episode\n",
    "    episode_log_probs: List[torch.Tensor] = []\n",
    "    episode_rewards: List[float] = []\n",
    "    \n",
    "    # --- Generate one episode --- \n",
    "    for t in range(MAX_STEPS_PER_EPISODE_REINFORCE):\n",
    "        # Select action based on current policy and store log probability\n",
    "        action, log_prob = select_action_reinforce(state, policy_net_reinforce)\n",
    "        episode_log_probs.append(log_prob)\n",
    "        \n",
    "        # Take action in the environment\n",
    "        next_state, reward, done = custom_env.step(action)\n",
    "        episode_rewards.append(reward)\n",
    "        \n",
    "        # Move to the next state\n",
    "        state = next_state\n",
    "        \n",
    "        # Break if the episode finished\n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "    # --- Episode finished, now update the policy --- \n",
    "    \n",
    "    # Calculate discounted returns for the episode\n",
    "    returns = calculate_discounted_returns(episode_rewards, GAMMA_REINFORCE, STANDARDIZE_RETURNS)\n",
    "    \n",
    "    # Perform policy optimization\n",
    "    loss = optimize_policy(episode_log_probs, returns, optimizer_reinforce)\n",
    "    \n",
    "    # Store episode statistics\n",
    "    total_reward = sum(episode_rewards)\n",
    "    episode_rewards_reinforce.append(total_reward)\n",
    "    episode_lengths_reinforce.append(t + 1)\n",
    "    episode_losses_reinforce.append(loss)\n",
    "\n",
    "    # Print progress periodically (e.g., every 100 episodes)\n",
    "    if (i_episode + 1) % 100 == 0:\n",
    "        avg_reward = np.mean(episode_rewards_reinforce[-100:])\n",
    "        avg_length = np.mean(episode_lengths_reinforce[-100:])\n",
    "        avg_loss = np.mean(episode_losses_reinforce[-100:])\n",
    "        print(\n",
    "            f\"Episode {i_episode+1}/{NUM_EPISODES_REINFORCE} | \"\n",
    "            f\"Avg Reward (last 100): {avg_reward:.2f} | \"\n",
    "            f\"Avg Length: {avg_length:.2f} | \"\n",
    "            f\"Avg Loss: {avg_loss:.4f}\"\n",
    "        )\n",
    "\n",
    "print(\"Custom Grid World Training Finished (REINFORCE).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Learning Process\n",
    "\n",
    "Plot the results (rewards, episode lengths) for the REINFORCE agent on the custom Grid World environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for REINFORCE on Custom Grid World\n",
    "plt.figure(figsize=(20, 4))\n",
    "\n",
    "# Rewards\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(episode_rewards_reinforce)\n",
    "plt.title('REINFORCE Custom Grid: Episode Rewards')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Total Reward')\n",
    "plt.grid(True)\n",
    "# Add moving average\n",
    "rewards_ma_reinforce = np.convolve(episode_rewards_reinforce, np.ones(100)/100, mode='valid')\n",
    "if len(rewards_ma_reinforce) > 0: \n",
    "    plt.plot(np.arange(len(rewards_ma_reinforce)) + 99, rewards_ma_reinforce, label='100-episode MA', color='orange')\n",
    "plt.legend()\n",
    "\n",
    "# Lengths\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(episode_lengths_reinforce)\n",
    "plt.title('REINFORCE Custom Grid: Episode Lengths')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Steps')\n",
    "plt.grid(True)\n",
    "# Add moving average\n",
    "lengths_ma_reinforce = np.convolve(episode_lengths_reinforce, np.ones(100)/100, mode='valid')\n",
    "if len(lengths_ma_reinforce) > 0:\n",
    "    plt.plot(np.arange(len(lengths_ma_reinforce)) + 99, lengths_ma_reinforce, label='100-episode MA', color='orange')\n",
    "plt.legend()\n",
    "\n",
    "# Loss\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(episode_losses_reinforce)\n",
    "plt.title('REINFORCE Custom Grid: Episode Loss')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Loss')\n",
    "plt.grid(True)\n",
    "# Add moving average\n",
    "losses_ma_reinforce = np.convolve(episode_losses_reinforce, np.ones(100)/100, mode='valid')\n",
    "if len(losses_ma_reinforce) > 0:\n",
    "    plt.plot(np.arange(len(losses_ma_reinforce)) + 99, losses_ma_reinforce, label='100-episode MA', color='orange')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of REINFORCE Learning Curves (Custom Grid World):**\n",
    "\n",
    "1.  **Episode Rewards (Left Plot):**\n",
    "    The agent shows very fast initial learning, rapidly increasing episode rewards to near-optimal levels within ~150 episodes. The moving average confirms convergence to a high reward policy. However, the raw rewards remain highly volatile throughout training, showcasing the characteristic high variance of the basic REINFORCE algorithm due to using noisy Monte Carlo returns for updates.\n",
    "\n",
    "2.  **Episode Lengths (Middle Plot):**\n",
    "    This plot strongly confirms efficient learning, mirroring the reward curve's trend. Episode lengths plummet dramatically early on, quickly converging to a stable, near-optimal average around 18 steps (the shortest path in the 10x10 grid). This indicates the agent successfully learned to find efficient paths to the goal state consistently.\n",
    "\n",
    "3.  **Episode Loss (Right Plot):**\n",
    "    The policy gradient loss exhibits extreme variance, directly reflecting the noisy Monte Carlo return estimates used in REINFORCE updates. Unlike MSE loss, it doesn't converge to zero but stabilizes on average after the initial learning phase. This high variance in the loss/gradient estimate is the primary reason for the volatility seen in the rewards curve.\n",
    "\n",
    "**Overall Conclusion:**\n",
    "REINFORCE successfully and quickly solved the custom Grid World task, learning an efficient policy to maximize rewards. The plots clearly demonstrate rapid convergence but also highlight the algorithm's inherent high variance in reward signals and gradient estimates, a key limitation compared to more advanced policy gradient or actor-critic methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing the Learned Policy (Optional Visualization)\n",
    "\n",
    "We adapt the policy grid visualization from the DQN notebook to use the Policy Network. It shows the most probable action (argmax of the policy output) for each state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Plotting Learned Policy from REINFORCE:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_reinforce_policy_grid(policy_net: PolicyNetwork, env: GridEnvironment, device: torch.device) -> None:\n",
    "    \"\"\"\n",
    "    Plots the greedy policy derived from the REINFORCE policy network.\n",
    "    Note: Shows the most likely action, not a sample.\n",
    "\n",
    "    Parameters:\n",
    "    - policy_net (PolicyNetwork): The trained policy network.\n",
    "    - env (GridEnvironment): The custom grid environment.\n",
    "    - device (torch.device): The device (CPU/GPU).\n",
    "\n",
    "    Returns:\n",
    "    - None: Displays the policy grid plot.\n",
    "    \"\"\"\n",
    "    rows: int = env.rows\n",
    "    cols: int = env.cols\n",
    "    policy_grid: np.ndarray = np.empty((rows, cols), dtype=str)\n",
    "    action_symbols: Dict[int, str] = {0: '↑', 1: '↓', 2: '←', 3: '→'}\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(cols * 0.6, rows * 0.6))\n",
    "\n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            state_tuple: Tuple[int, int] = (r, c)\n",
    "            if state_tuple == env.goal_state:\n",
    "                policy_grid[r, c] = 'G'\n",
    "                ax.text(c, r, 'G', ha='center', va='center', color='green', fontsize=12, weight='bold')\n",
    "            else:\n",
    "                state_tensor: torch.Tensor = env._get_state_tensor(state_tuple)\n",
    "                with torch.no_grad():\n",
    "                    state_tensor = state_tensor.unsqueeze(0)\n",
    "                    # Get action probabilities\n",
    "                    action_probs: torch.Tensor = policy_net(state_tensor)\n",
    "                    # Select the action with the highest probability (greedy action)\n",
    "                    best_action: int = action_probs.argmax(dim=1).item()\n",
    "\n",
    "                policy_grid[r, c] = action_symbols[best_action]\n",
    "                ax.text(c, r, policy_grid[r, c], ha='center', va='center', color='black', fontsize=12)\n",
    "\n",
    "    ax.matshow(np.zeros((rows, cols)), cmap='Greys', alpha=0.1)\n",
    "    ax.set_xticks(np.arange(-.5, cols, 1), minor=True)\n",
    "    ax.set_yticks(np.arange(-.5, rows, 1), minor=True)\n",
    "    ax.grid(which='minor', color='black', linestyle='-', linewidth=1)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_title(\"REINFORCE Learned Policy (Most Likely Action)\")\n",
    "    plt.show()\n",
    "\n",
    "# Plot the policy learned by the trained network\n",
    "print(\"\\nPlotting Learned Policy from REINFORCE:\")\n",
    "plot_reinforce_policy_grid(policy_net_reinforce, custom_env, device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Solutions in REINFORCE\n",
    "\n",
    "**Challenge: High Variance in Gradient Estimates**\n",
    "*   **Problem:** Using the full Monte Carlo return $G_t$ makes the gradient estimate noisy, as a single good or bad action early in a long episode can unduly affect the updates for all preceding actions, even unrelated ones.\n",
    "*   **Solutions**:\n",
    "    *   **Baseline Subtraction:** Subtract a state-dependent baseline (like the state value $V(s_t)$) from $G_t$: update using $(G_t - V(s_t)) \\nabla \\log \\pi$. This reduces variance without biasing the gradient. Requires learning $V(s_t)$, leading towards Actor-Critic methods.\n",
    "    *   **Standardize Returns:** Normalize the returns within an episode or batch (subtract mean, divide by standard deviation). This helps stabilize updates.\n",
    "    *   **Increase Batch Size:** Average gradients over multiple episodes before updating (though this requires more memory).\n",
    "\n",
    "**Challenge: Slow Convergence**\n",
    "*   **Problem:** High variance and potentially small learning steps can lead to slow learning.\n",
    "*   **Solutions**:\n",
    "    *   **Tune Learning Rate:** Careful tuning is crucial. Adaptive learning rates (Adam optimizer is often used) can help.\n",
    "    *   **Use Baselines:** As mentioned above, variance reduction speeds up convergence.\n",
    "    *   **Actor-Critic Methods:** Replace Monte Carlo returns $G_t$ with bootstrapped estimates like the TD error from a learned critic (value function), leading to faster, lower-variance updates (e.g., A2C, A3C).\n",
    "\n",
    "**Challenge: On-Policy Data Inefficiency**\n",
    "*   **Problem:** REINFORCE must discard data after each policy update, making it less sample efficient than off-policy methods like DQN.\n",
    "*   **Solutions**:\n",
    "    *   **Importance Sampling:** Techniques used in off-policy policy gradient methods (like PPO) allow reusing old data to some extent, but add complexity.\n",
    "    *   **Accept the Limitation:** For simpler problems or when interaction cost is low, the simplicity of on-policy updates might be preferred.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "REINFORCE is a foundational policy gradient algorithm in reinforcement learning. It directly optimizes a parameterized policy by adjusting action probabilities based on the complete discounted returns obtained during episodes. Its core strength lies in its conceptual simplicity and ability to handle various action spaces and learn stochastic policies.\n",
    "\n",
    "As demonstrated with the custom Grid World, REINFORCE can learn effective policies. However, its practical application is often limited by the high variance inherent in its Monte Carlo gradient estimates, which can lead to instability or slow convergence. Techniques like baseline subtraction and return standardization are common additions to mitigate this. REINFORCE serves as a crucial stepping stone to understanding more advanced and widely used policy gradient and actor-critic methods (like A2C, A3C, DDPG, PPO, SAC) which build upon its core principles while addressing its limitations, particularly variance and sample efficiency."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
